Programmable integrated circuits (ICs) are a well-known type of IC that can be programmed to perform specified logic functions. One type of programmable IC, the field programmable gate array (FPGA), typically includes an array of programmable tiles. These programmable tiles can include, for example, input/output blocks (IOBs), configurable logic blocks (CLBs), dedicated random access memory blocks (BRAM), multipliers, digital signal processing blocks (DSPs), processors, clock managers, delay lock loops (DLLs), and so forth.
Each programmable tile typically includes both programmable interconnect circuitry and programmable logic circuitry. The programmable interconnect circuitry typically includes a large number of interconnect lines of varying lengths interconnected by programmable interconnect points (PIPs). The programmable logic circuitry implements the logic of a user design using programmable elements that can include, for example, function generators, registers, arithmetic logic, and so forth.
The programmable interconnect circuitry and programmable logic circuitry are typically programmed by loading a stream of configuration data into internal configuration memory cells that define how the programmable elements are configured. The configuration data can be read from memory (e.g., from an external PROM) or written into the FPGA by an external device. The collective states of the individual memory cells then determine the function of the FPGA.
Another type of programmable IC is the complex programmable logic device, or CPLD. A CPLD includes two or more “function blocks” connected together and to input/output (I/O) resources by an interconnect switch matrix. Each function block of the CPLD includes a two-level AND/OR structure similar to those used in programmable logic arrays (PLAs) and programmable array logic (PAL) devices. In CPLDs, configuration data is typically stored on-chip in non-volatile memory. In some CPLDs, configuration data is stored on-chip in non-volatile memory, then downloaded to volatile memory as part of an initial configuration (programming) sequence.
For all of these programmable ICs, the functionality of the device is controlled by data bits provided to the device for that purpose. The data bits can be stored in volatile memory (e.g., static memory cells, as in FPGAs and some CPLDs), in non-volatile memory (e.g., FLASH memory, as in some CPLDs), or in any other type of memory cell.
Other programmable ICs are programmed by applying a processing layer, such as a metal layer, that programmably interconnects the various elements on the device. These programmable ICs are known as mask programmable devices. Programmable ICs can also be implemented in other ways, e.g., using fuse or antifuse technology. The phrase “programmable IC” can include, but is not limited to these devices and further can encompass devices that are only partially programmable. For example, one type of programmable IC includes a combination of hard-coded transistor logic and a programmable switch fabric that programmably interconnects the hard-coded transistor logic.
Programmable ICs are often incorporated into larger systems that include, for example, a processor. In some cases, the processor can be implemented as a functional block within the programmable IC. Processors operate through execution of program code stored within a memory. The memory is typically implemented as a random access memory (RAM). The RAM allows the processor to access particular words, bytes, and/or bits of data stored therein. As systems become more complex, an increased quantity of memory often is required to store program code for the processor. Increased memory requirements typically translate into increased costs for implementing the system.
Other memory technologies that are less expensive than RAM, e.g., non-volatile I/O devices, lack features necessary to support execution of program code. For example, flash memory, one type of non-volatile I/O device, is only able to address an entire data block at any given time. Read and/or write operations directed to I/O devices such as, for example, serial peripheral interface (SPI) flash, queued serial peripheral interface (QSPI) flash, serial advanced technology attachment (SATA) flash, and NAND flash memories, are typically executed upon a data block of a predetermined and unchanging size irrespective of the operation being performed or the size of data affected by the operation. The data block is typically an address range formed of hundreds or thousands of bytes. For example, a read operation reads one or more data blocks from the flash memory. A write operation writes one or more data blocks to the flash memory. Flash memory lacks the ability to access specific locations in memory such as a word, a byte, or a particular bit, as is possible with RAM. As such, random access of data, e.g., such as a bit, a byte, or a word, from SPI, QSPI, SATA, or NAND flash memories is not possible since these devices operate only upon entire data blocks at any given time. This makes flash memory unsuitable for use as execution memory in processor based systems.